home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / rotimg / rotimg.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  7.9 KB  |  447 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /* rotat image
  18.  * Thant Tessman - April, '88
  19.  *
  20.  */
  21.  
  22. #include <stdio.h>
  23. #include <gl.h>
  24. #include <math.h>
  25. #include <device.h>
  26. #include <gl/image.h>
  27.  
  28. #define X 0
  29. #define Y 1
  30. #define Z 2
  31.  
  32. short rb[2048];
  33. short gb[2048];
  34. short bb[2048];
  35.  
  36. unsigned long *colors;
  37.  
  38. float *grid;
  39.  
  40. float dist=0.0, d_dist=0.0;
  41. Angle azim=0, inc=0, twist=0;
  42. Angle d_azim=0, d_inc=0;
  43.  
  44. short mx, my, omx, omy, nmx, nmy;
  45. int origx, origy, sizex, sizey;
  46.  
  47. short dev, val;
  48. int active=TRUE;
  49. long gid;
  50. int menu;
  51.  
  52. int low_res, low_tmp;
  53.  
  54. int function=0;
  55. #define REORIENT 1
  56. #define REDISTANCE 2
  57.  
  58. float ident_matrix[4][4] = {
  59.     {1.0, 0.0, 0.0, 0.0},
  60.     {0.0, 1.0, 0.0, 0.0},
  61.     {0.0, 0.0, 1.0, 0.0},
  62.     {0.0, 0.0, 0.0, 1.0},
  63. };
  64.  
  65. int y, xsize, ysize;
  66.  
  67. char *title;
  68.  
  69. main (argc, argv)
  70. int argc;
  71. char **argv;
  72. {
  73.     IMAGE *image;
  74.  
  75.     char *strrchr();
  76.  
  77.     title = (title=strrchr(argv[0], '/')) != NULL ? title+1 : argv[0];
  78.  
  79.     if( argc<2 ) {
  80.     fprintf(stderr, "usage: %s infile\n", title);
  81.     exit(1);
  82.     } 
  83.     if( (image=iopen(argv[1],"r")) == NULL ) {
  84.     fprintf(stderr, "%s: can't open input file %s\n", title, argv[1]);
  85.     exit(1);
  86.     }
  87.     if( image->zsize < 3 ) {
  88.     fprintf(stderr, "%s: input image is not a color image\n", title);
  89.     exit(1);
  90.     }
  91.     xsize = image->xsize;
  92.     ysize = image->ysize;
  93.  
  94.     low_tmp = low_res = (xsize+ysize)/100+1;
  95.  
  96.     colors = (unsigned long *)malloc(xsize*ysize*sizeof(unsigned long));
  97.     grid = (float *)malloc(xsize * ysize * 3 * sizeof(int));
  98.  
  99.     fprintf(stderr, "%s: loading image.  Please wait...", title);
  100.  
  101.     initialize();
  102.  
  103.     for(y=0; y<ysize; y++) {
  104.  
  105.     getrow(image, rb, y, 0);
  106.     load_colors(rb, colors, xsize, y, 'r');
  107.  
  108.     getrow(image, gb, y, 1);
  109.     load_colors(gb, colors, xsize, y, 'g');
  110.  
  111.     getrow(image, bb, y, 2);
  112.     load_colors(bb, colors, xsize, y, 'b');
  113.  
  114.     }
  115.  
  116.     fprintf(stderr, "Done!\n");
  117.  
  118.     draw_scene();
  119.  
  120.     while(TRUE) {
  121.  
  122.     while(qtest() || (!function && low_tmp<2)) {
  123.         dev=qread(&val);
  124.         switch(dev) {
  125.  
  126.         case INPUTCHANGE:
  127.             active = val;
  128.             if (val);
  129.             break;
  130.  
  131.         case ESCKEY :
  132.             if (val) break;
  133.         case WINQUIT:
  134.             gexit();
  135.             exit(0);
  136.  
  137.         case LEFTMOUSE:
  138.             mx = getvaluator(MOUSEX);
  139.             my = getvaluator(MOUSEY);
  140.             if (val) {
  141.             function=REDISTANCE;
  142.  
  143. /* these are commented out because of a bug in journaling 
  144.  * (can't handle setvaluators)
  145.  */
  146.  
  147. /*            setvaluator(MOUSEX, mx, origx+1, origx+sizex-1);
  148.             setvaluator(MOUSEY, my, origy+1, origy+sizey-1);
  149. */
  150.             omx = mx; omy = my;
  151.             } else {
  152.             function=0;
  153. /*            setvaluator(MOUSEX, mx, 0, XMAXSCREEN);
  154.             setvaluator(MOUSEY, my, 0, YMAXSCREEN);
  155. */
  156.             dist += d_dist; d_dist = 0.0;
  157.             draw_scene();
  158.             }
  159.             break;
  160.  
  161.         case MIDDLEMOUSE:
  162.             mx = getvaluator(MOUSEX);
  163.             my = getvaluator(MOUSEY);
  164.             if (val) {
  165.             function=REORIENT;
  166. /*            setvaluator(MOUSEX, mx, origx+1, origx+sizex-1);
  167.             setvaluator(MOUSEY, my, origy+1, origy+sizey-1);
  168. */
  169.             omx = mx; omy = my;
  170.             } else {
  171.             function=0;
  172. /*            setvaluator(MOUSEX, mx, 0, XMAXSCREEN);
  173.             setvaluator(MOUSEY, my, 0, YMAXSCREEN);
  174. */
  175.             azim += d_azim; d_azim = 0;
  176.             inc += d_inc; d_inc = 0;
  177.             draw_scene();
  178.             }
  179.             break;
  180.  
  181.         case RIGHTMOUSE:
  182.             if (val) {
  183.             switch (dopup(menu)) {
  184.  
  185.                 case 1:
  186.                 setup_flat_grid();
  187.                 break;
  188.  
  189.                 case 2:
  190.                 setup_wavy_grid();
  191.                 break;
  192.             }
  193.             low_tmp=low_res;
  194.             draw_scene();
  195.             }
  196.             break;
  197.  
  198.         case REDRAW:
  199.             reshapeviewport();
  200.             getorigin(&origx, &origy);
  201.             getsize(&sizex, &sizey);
  202.             draw_scene();
  203.             break;
  204.         }
  205.     }
  206.  
  207.     switch(function) {
  208.  
  209.         case REORIENT:
  210.         mx = getvaluator(MOUSEX);
  211.         my = getvaluator(MOUSEY);
  212.         d_azim = (omx - mx) * 2 * getgdesc(GD_XPMAX) / sizex;
  213.         d_inc = (my - omy) * 2 * getgdesc(GD_YPMAX) / sizey;
  214.         break;
  215.  
  216.         case REDISTANCE:
  217.         mx = getvaluator(MOUSEX);
  218.         my = getvaluator(MOUSEY);
  219.         d_dist = ((omx - mx) + (my - omy)) * getgdesc(GD_XPMAX) /sizex;
  220.         break;
  221.     }
  222.  
  223.         draw_scene();
  224.  
  225.     }
  226. }
  227.  
  228.  
  229. initialize() {
  230.  
  231.     keepaspect(xsize, ysize);
  232.     gid=winopen(title);
  233.     if (getgdesc(GD_BITS_NORM_SNG_RED) == 0)
  234.      {
  235.       system("inform 'Your system must support RGB mode to run rotimg'");
  236.         exit(1);
  237.     }
  238.      if (getgdesc(GD_BITS_NORM_ZBUFFER) == 0)
  239.      {
  240.       system("inform 'Your system must have a z-buffer to run rotimg'");
  241.       exit(1);
  242.      }
  243.     doublebuffer();
  244.     RGBmode();
  245.     gconfig();
  246.     RGBcolor(0, 0, 0);
  247.     clear(); swapbuffers(); clear();
  248.     qdevice(INPUTCHANGE);
  249.     qdevice(REDRAW);
  250.     qdevice(ESCKEY);
  251.     qdevice(WINQUIT);
  252.     qdevice(LEFTMOUSE);
  253.     qdevice(MIDDLEMOUSE);
  254.     qdevice(RIGHTMOUSE);
  255.  
  256.     getorigin(&origx, &origy);
  257.     getsize(&sizex, &sizey);
  258.  
  259.     zbuffer(TRUE);
  260.     lsetdepth(0x00, 0x7fffff);
  261.  
  262.     clear_color_grid();
  263.     setup_flat_grid();
  264.  
  265.     dist = ysize/2;
  266.  
  267.     menu = defpup("flat|wavy");
  268.  
  269. }
  270.  
  271.  
  272. clear_color_grid() {
  273.  
  274.     int i, j;
  275.  
  276.     for (j=0; j<ysize; j++) {
  277.     for (i=0; i<xsize; i++) {
  278.  
  279.         colors[j*xsize + i] = 0;
  280.  
  281.     }
  282.     }
  283. }
  284.  
  285.  
  286. setup_wavy_grid() {
  287.  
  288.     int i, j;
  289.  
  290.     float a, b, x, y, r;
  291.  
  292.     r = xsize/4;
  293.  
  294.     for (j=0; j<ysize; j++) {
  295.     b = (float) j * 3.14159265359 / ysize;
  296.     y = cos(b*3) * r;
  297.  
  298.     for (i=0; i<xsize; i++) {
  299.  
  300.         a = (float) i * 3.14159265359 / xsize;
  301.         x = cos(a*2) * r;
  302.  
  303.         grid[3 * (j*xsize + i) + 0] = i - xsize/2;
  304.         grid[3 * (j*xsize + i) + 1] = j - ysize/2;
  305.         grid[3 * (j*xsize + i) + 2] = x + y;
  306.  
  307.     }
  308.     }
  309. }
  310.  
  311.  
  312. setup_flat_grid() {
  313.  
  314.     int i, j;
  315.  
  316.  
  317.     for (j=0; j<ysize; j++) {
  318.     for (i=0; i<xsize; i++) {
  319.  
  320.         grid[3 * (j*xsize + i) + 0] = i - xsize/2;
  321.         grid[3 * (j*xsize + i) + 1] = j - ysize/2;
  322.         grid[3 * (j*xsize + i) + 2] = 0;
  323.  
  324.     }
  325.     }
  326. }
  327.  
  328.  
  329. draw_grid() {
  330.  
  331.     register int i, j;
  332.     register float *gp1, *gp2;
  333.     register unsigned long *cp1, *cp2;
  334.  
  335.     for (j=0; (j<ysize-1) && !qtest(); j++) {
  336.  
  337.     gp1 = &grid[3 * j * xsize];
  338.     gp2 = &grid[3 * (j+1) * xsize];
  339.     cp1 = &colors[j * xsize];
  340.     cp2 = &colors[(j+1) * xsize];
  341.  
  342.     bgntmesh();
  343.     for (i=0; i<xsize-1; i++) {
  344.         cpack(*cp1++);
  345.         v3f(gp1+=3);
  346.         cpack(*cp2++);
  347.         v3f(gp2+=3);
  348.     }
  349.     endtmesh();
  350.     }
  351. }
  352.  
  353.  
  354. draw_quick_grid(s)
  355. int s;
  356. {
  357.  
  358.     register int i, j, t;
  359.     register float *gp1, *gp2;
  360.     register unsigned long *cp1, *cp2;
  361.  
  362.     t = s * 3;
  363.  
  364.     for (j=0; (j<ysize-2) && !qtest(); j+=2) {
  365.  
  366.     gp1 = &grid[3 * j * xsize];
  367.     gp2 = &grid[3 * (j+2) * xsize];
  368.     cp1 = &colors[j * xsize];
  369.     cp2 = &colors[(j+2) * xsize];
  370.  
  371.     bgntmesh();
  372.     for (i=0; i<xsize-s; i+=s) {
  373.         cp1+=s;
  374.         cpack(*cp1);
  375.         v3f(gp1 += t);
  376.         cp2+=s;
  377.         cpack(*cp2);
  378.         v3f(gp2 += t);
  379.     }
  380.     endtmesh();
  381.     }
  382. }
  383.  
  384.  
  385. draw_scene() {
  386.  
  387.     RGBcolor(0, 0, 0);
  388.     clear();
  389.     zclear();
  390.  
  391.     perspective(900, (float)xsize/(float)ysize, 1.0, 5000.0);
  392.  
  393.     polarview(dist+d_dist, azim+d_azim, inc+d_inc, twist);
  394.  
  395.     if (function) draw_quick_grid(low_tmp=low_res);
  396.  
  397.     else {
  398.  
  399.     low_tmp = low_tmp/2;
  400.  
  401.     if (low_tmp>1) draw_quick_grid(low_tmp);
  402.     else {draw_grid();
  403.         low_tmp=0;
  404.     }
  405.     }
  406.  
  407.     if (!qtest()) swapbuffers();
  408. }
  409.  
  410.  
  411. load_colors(row, dest, xsize, y, c)
  412. short *row;
  413. unsigned long *dest;
  414. int xsize, y;
  415. char c;
  416. {
  417.     int pos;
  418.  
  419.     pos = xsize * y;
  420.     dest = &dest[pos];
  421.     switch (c) {
  422.  
  423.     case 'r':
  424.     case 'R':
  425.         while(xsize--) {
  426.         *dest = *dest++ + *row++;
  427.         }
  428.         break;
  429.  
  430.     case 'g':
  431.     case 'G':
  432.         while(xsize--) {
  433.         *dest = *dest++ + ((*row++) << 8);
  434.         }
  435.         break;
  436.  
  437.     case 'b':
  438.     case 'B':
  439.         while(xsize--) {
  440.         *dest = *dest++ + ((*row++) << 16);
  441.         }
  442.         break;
  443.     }
  444.  
  445. }
  446.  
  447.